const http = require('http');
const fs = require('fs');
const path = require('path');
const formidable = require('formidable');

// 配置常量
const PORT = 8081;
const UPLOAD_DIR = path.join(__dirname, 'upload');
const PUBLIC_DIR = path.join(__dirname, 'public');

// 确保upload目录存在
if (!fs.existsSync(UPLOAD_DIR)) {
  fs.mkdirSync(UPLOAD_DIR, { recursive: true });
  console.log(`已创建图片保存目录：${UPLOAD_DIR}`);
}

// 创建HTTP服务
const server = http.createServer((req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Content-Type', 'text/html; charset=utf-8');

  // 路由：GET / → 返回上传页面
  if (req.method === 'GET' && req.url === '/') {
    fs.readFile(path.join(PUBLIC_DIR, 'upload.html'), 'utf8', (err, data) => {
      if (err) {
        res.writeHead(404);
        return res.end('<h3>错误：上传页面不存在</h3>');
      }
      res.writeHead(200);
      res.end(data);
    });
  }

  // 路由：POST / → 处理图片上传
  else if (req.method === 'POST' && req.url === '/') {
    const form = formidable({
      uploadDir: UPLOAD_DIR,
      keepExtensions: false, // 先不保留扩展名，后续手动添加
      maxFileSize: 5 * 1024 * 1024, // 限制5MB
      filter: (part) => part.mimetype && part.mimetype.startsWith('image/')
    });

    form.parse(req, (err, fields, files) => {
      if (err) {
        res.writeHead(400);
        let errorMsg = '上传失败：';
        if (err.code === 'LIMIT_FILE_SIZE') {
          errorMsg += '文件大小超过限制（最大5MB）';
        } else if (err.message.includes('filtered out')) {
          errorMsg += '仅支持图片类型文件';
        } else {
          errorMsg += err.message;
        }
        return res.end(`<h3>${errorMsg}</h3><a href="/">返回上传页面</a>`);
      }

      const imageFile = files.image;
      if (!imageFile) {
        res.writeHead(400);
        return res.end('<h3>错误：请选择要上传的图片</h3><a href="/">返回上传页面</a>');
      }

      // 重命名文件，添加正确的扩展名
      const oldPath = imageFile.filepath;
      const originalName = imageFile.originalFilename || '';
      const ext = path.extname(originalName).toLowerCase() || getExtFromMime(imageFile.mimetype);
      
      // 如果没有扩展名，根据MIME类型猜测
      if (!ext) {
        res.writeHead(400);
        return res.end('<h3>错误：无法识别图片格式</h3><a href="/">返回上传页面</a>');
      }

      const baseName = path.basename(originalName, path.extname(originalName)) || 
                      path.basename(oldPath, path.extname(oldPath));
      const newPath = path.join(UPLOAD_DIR, `${baseName}${ext}`);

      // 防止文件名重复
      const finalPath = getUniquePath(newPath);

      fs.rename(oldPath, finalPath, (renameErr) => {
        if (renameErr) {
          res.writeHead(500);
          return res.end('<h3>错误：图片保存失败</h3><a href="/">返回上传页面</a>');
        }

        res.writeHead(200);
        res.end(`
          <h3>图片上传成功！</h3>
          <p>文件名：${path.basename(finalPath)}</p>
          <p>文件大小：${(imageFile.size / 1024).toFixed(2)} KB</p>
          <a href="/">继续上传图片</a> | 
          <a href="/list">查看图片列表</a>
        `);
        console.log(`已保存图片：${finalPath}`);
      });
    });
  }

  // 其他路由（保持不变）
  // ...
});

// 辅助函数：根据MIME类型获取扩展名
function getExtFromMime(mimetype) {
  if (!mimetype) return '';
  const map = {
    'image/jpeg': '.jpg',
    'image/png': '.png',
    'image/gif': '.gif',
    'image/webp': '.webp',
    'image/svg+xml': '.svg'
  };
  return map[mimetype.toLowerCase()] || '';
}

// 辅助函数：获取不重复的文件路径
function getUniquePath(filePath) {
  if (!fs.existsSync(filePath)) return filePath;
  
  const dir = path.dirname(filePath);
  const ext = path.extname(filePath);
  const name = path.basename(filePath, ext);
  
  let counter = 1;
  while (true) {
    const newPath = path.join(dir, `${name}_${counter}${ext}`);
    if (!fs.existsSync(newPath)) return newPath;
    counter++;
  }
}

server.listen(PORT, () => {
  console.log(`HTTP服务端已启动！`);
  console.log(`访问上传页面：http://localhost:${PORT}`);
  console.log(`访问图片列表：http://localhost:${PORT}/list`);
});